
# ----- Always run this at the beginning of class so we can get multi-command output ----- #

# Access options from the iPython core
from IPython.core.interactiveshell import InteractiveShell

# Change the value of ast_node_interactivity
InteractiveShell.ast_node_interactivity = "all"

# ----- Additional packages we want to import for class ----- #

# Import the pandas package
import pandas as pd
import re


# Import the regular expression package
import re


# Print a list of all matches:

txt = "The rain in Spain"
x = re.findall("[rp]ain", txt)
print(x)

['rain', 'pain']


txt = "The rain in Spain"
x = re.search("[rp]ain", txt) # There are two "in" in txt but only the first match is returned

# What result is returned
x

# What is it's typing?
type(x)

<re.Match object; span=(4, 8), match='rain'>

re.Match


txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt) # Anything that starts with "The" and ends in "Spain"

x

<re.Match object; span=(0, 17), match='The rain in Spain'>


# Search for the first white-space character in the string:

txt = "The rain in Spain"
x = re.search("\s", txt)

print("The first white-space character is located in index position:", x.start())

The first white-space character is located in index position: 3


# Split at each white-space character:
txt = "The rain in Spain"

x = re.split("\s", txt)
print(x)

['The', 'rain', 'in', 'Spain']


# Split the string only at the first occurrence:
txt = "The rain in Spain"

x = re.split("\s", txt, maxsplit = 1) #  Number of strings = n+1 strings, where n =  number of splits). One split creates two new strings, 2 splits creates 3, and so on
print(x)

['The', 'rain in Spain']


# Replace every white-space character with the number 9:
txt = "The rain in Spain"

x = re.sub("\s", "9", txt)
print(x)

The9rain9in9Spain


# Replace the first 2 occurrences:
txt = "The rain in Spain"

x = re.sub("\s", "9", txt, count = 2)
print(x)

The9rain9in Spain


special_char = 'spec&al_character'

# Replace the & with an i
re.sub('&', 'i', special_char)

'special_character'


txt = "The rain in Spain"
x = re.search("[rp]ain", txt) # There are two "ain" words in our txt but only the first match is returned

# Where do we get a match?
x.span()

# What was the matching text?
x.group()

# What was our original search string?
x.string

# What was our original pattern?
x.re

(4, 8)

'rain'

'The rain in Spain'

re.compile(r'[rp]ain', re.UNICODE)


# Print the position (start- and end-position) of the first match occurrence.

txt = "The rain in Spain"

# The regular expression looks for any words that starts with an upper case "S":
x = re.search("\\bS\\w+", txt) 

# What did we search for?
x.re

# Where is our match (if any) located?
x.span()

# What did we find?
x.group()

re.compile(r'\bS\w+', re.UNICODE)

(12, 17)

'Spain'


# Here are some fun examples of what is happening inside text with and without extra escape characters

"this is the \b single-byte character. It happens with \a and \f as well but not \c or \w"
print("this is the \b single-byte character. It happens with \a and \f as well but not \c or \w")

# versus

"this is the \\b character. Here's \\a, \\f, \\c, and \\w"
print("this is the \\b character. Here's \\a, \\f, \\c, and \\w")

'this is the \x08 single-byte character. It happens with \x07 and \x0c as well but not \\c or \\w'

this is the  single-byte character. It happens with  and  as well but not \c or \w

"this is the \\b character. Here's \\a, \\f, \\c, and \\w"

this is the \b character. Here's \a, \f, \c, and \w


# Convert your regular expression into raw text
txt = "The rain in Spain"

x = re.search(r"\bS\w+", txt)

# is our result empty?
not x

# What did we search for?
x.re

# Where is our match (if any) located?
x.span()

# What did we find?
x.group()

False

re.compile(r'\bS\w+', re.UNICODE)

(12, 17)

'Spain'


# Let's make a "random" sequence
import random

random.seed(2022)

# Generate a 1000bp DNA sequence
seq = "".join(random.choices(["A", "C", "G", "T"], k=1000))

# Count the number of hits
len(re.findall(pattern = ..., string = ...))

# Where is the first occurrence?
re.search(...)


# Use a single + to concatenate

# Inside a print function
print('this is ' + 'a concatenated string')

# outside a print function
'this is ' + 'a concatenated string'

this is a concatenated string

'this is a concatenated string'


# It doesn't really matter if we include multiple concatenations to do the same thing

print('another' + ' ' + 'concatenated string')

another concatenated string


# The print function can automatically concatenate strings for us

# This only works inside print()
print('this is also', 'a concatenated string')

# This just makes a tuple
'this is also', 'a concatenated string'

this is also a concatenated string

('this is also', 'a concatenated string')


string_1 = 'evolution'

string_1[4] # 0 indexing when going forward on the string

string_1[-5] # reverese indexing has one-based indexing, meaning indices start at -1

'u'

'u'


string_1[4:7]

'uti'


# Index from 0 to 7 (exclusive) every two elements (it skips one every time)

string_1[0: 7: 2]

'eoui'


# Retrieve the reverse of our string
string_1[ : : -1]

# any clues where this type of string manipulation can be useful in biology?

'noitulove'


# Palindrome reversals
'Evil did I dwell. Lewd I did live'[:: -1]

'A man a plan a canal panama'[:: -1]

# Does this remind your of restriction sites? 
'GAATTC'[ : : -1]

# Of course we'd still have to take the complement of this sequence

'evil did I dweL .llewd I did livE'

'amanap lanac a nalp a nam A'

'CTTAAG'


# split our string using the letter "o"
string_1.split(sep = 'o', maxsplit = 1) 

# maxsplit is the max number of strings we want

# Compare this to the re.split function
re.split('o', string_1, maxsplit=1)

['ev', 'lution']

['ev', 'lution']


# Now split from the right side
string_1.rsplit(sep = 'o', maxsplit = 1)

['evoluti', 'n']


# a list of strings
cagef_seq = ['CAGEF', 'Sequencing', 'Educational', 'Outreach'] 

print('_'.join(cagef_seq)) # joins by underscore

type('_'.join(cagef_seq))

CAGEF_Sequencing_Educational_Outreach

str


othello = '''RODERIGO\nTush! never tell me; I take it much unkindly\nThat thou, Iago, who hast had my purse
As if the strings were thine, shouldst know of this.'''

othello

print()

othello.splitlines() # outputs a list of strings)

print()

# analogous to 
othello_list = othello.split('\n')
othello_list

'RODERIGO\nTush! never tell me; I take it much unkindly\nThat thou, Iago, who hast had my purse\nAs if the strings were thine, shouldst know of this.'

['RODERIGO',
 'Tush! never tell me; I take it much unkindly',
 'That thou, Iago, who hast had my purse',
 'As if the strings were thine, shouldst know of this.']

['RODERIGO',
 'Tush! never tell me; I take it much unkindly',
 'That thou, Iago, who hast had my purse',
 'As if the strings were thine, shouldst know of this.']


# There are many paths to the same place
# The key is knowing how to implement them properly
for i in othello_list:
    re.split(r"...", i)


# Import our re library if it hasn't already been imported
import re

# notice the triple quotes: Use them to create multiline strings 

dino = '''>DinoDNA from Crichton JURASSIC PARK  p. 103 nt 1-1200 
GCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC
CCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG
TGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT
GCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT
CACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG
ATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA
TCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG
AGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC
CCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT
CCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC
ACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT
CGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'''

dino

'>DinoDNA from Crichton JURASSIC PARK  p. 103 nt 1-1200 \nGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC\nCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG\nTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT\nGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT\nCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG\nATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA\nTCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG\nAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC\nCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT\nCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC\nACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT\nCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Use the sub function to pull the ">" and replace it with nothing
re.sub(r'^>', '', dino)

'DinoDNA from Crichton JURASSIC PARK  p. 103 nt 1-1200 \nGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC\nCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG\nTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT\nGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT\nCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG\nATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA\nTCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG\nAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC\nCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT\nCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC\nACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT\nCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Remove some leading characters from our string
dino.lstrip(r'>Dino')

'NA from Crichton JURASSIC PARK  p. 103 nt 1-1200 \nGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC\nCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG\nTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT\nGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT\nCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG\nATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA\nTCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG\nAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC\nCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT\nCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC\nACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT\nCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Search for all digits 0-9 and replace with nothing
re.sub(r'[0-9]', '', dino) # \d any digit, + is more than one digit

'>DinoDNA from Crichton JURASSIC PARK  p.  nt - \nGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC\nCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG\nTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT\nGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT\nCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG\nATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA\nTCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG\nAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC\nCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT\nCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC\nACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT\nCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Will this replace all whitespace characters?
dino.replace(' ', '')

'>DinoDNAfromCrichtonJURASSICPARKp.103nt1-1200\nGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCC\nCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGG\nTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGT\nGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGT\nCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATG\nATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGA\nTCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAG\nAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTC\nCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTAT\nCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCC\nACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCAT\nCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Matches any whitespace character; this is equivalent to the class [ \t\n\r\f\v].re.sub('\s', '', dino)    
re.sub(r'\s', '', dino)

'>DinoDNAfromCrichtonJURASSICPARKp.103nt1-1200GCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGTGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGTCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATGATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGATCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAGAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCCACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCATCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Use findall to confirm what our regex is finding
re.findall(r'^>.*[0-9]\s|\n', dino)
# | (or) statement needed to remove all line breaks, otherwise only the first one is removed

# Substitute that into sub()
re.sub(r'^>.*[0-9]\s|\n', '', dino) # ^ matches the begining of line

['>DinoDNA from Crichton JURASSIC PARK  p. 103 nt 1-1200 ',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n']

'GCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGTGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGTCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATGATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGATCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAGAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCCACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCATCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Use findall to with lazy matching
re.findall(r'^>.*?[0-9]\s|\n', dino)

['>DinoDNA from Crichton JURASSIC PARK  p. 103 ',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n',
 '\n']


# Save our replaced result to a variable: dna
dna = re.sub('^>.*[0-9]\s|\n', '', dino)
dna

'GCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAAAATCGACGCGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCTCCCTCGTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGAAGCGTGGCTGCTCACGCTGTACCTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGGGCTGTGTGCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACCCGGTAAAGTAGGACAGGTGCCGGCAGCGCTCTGGGTCATTTTCGGCGAGGACCGCTTTCGCTGGAGATCGGCCTGTCGCTTGCGGTATTCGGAATCTTGCACGCCCTCGCTCAAGCCTTCGTCACTCCAAACGTTTCGGCGAGAAGCAGGCCATTATCGCCGGCATGGCGGCCGACGCGCTGGGCTGGCGTTCGCGACGCGAGGCTGGATGGCCTTCCCCATTATGATTCTTCTCGCTTCCGGCGGCCCGCGTTGCAGGCCATGCTGTCCAGGCAGGTAGATGACGACCATCAGGGACAGCTTCAACGGCTCTTACCAGCCTAACTTCGATCACTGGACCGCTGATCGTCACGGCGATTTATGCCGCACATGGACGCGTTGCTGGCGTTTTTCCATAGGCTCCGCCCCCCTGACGAGCATCACAAACAAGTCAGAGGTGGCGAAACCCGACAGGACTATAAAGATACCAGGCGTTTCCCCCTGGAAGCGCTCTCCTGTTCCGACCCTGCCGCTTACCGGATACCTGTCCGCCTTTCTCCCTTCGGGCTTTCTCAATGCTCACGCTGTAGGTATCTCAGTTCGGTGTAGGTCGTTCGCTCCAAGCTGACGAACCCCCCGTTCAGCCCGACCGCTGCGCCTTATCCGGTAACTATCGTCTTGAGTCCAACACGACTTAACGGGTTGGCATGGATTGTAGGCGCCGCCCTATACCTTGTCTGCCTCCCCGCGGTGCATGGAGCCGGGCCACCTCGACCTGAATGGAAGCCGGCGGCACCTCGCTAACGGCCAAGAATTGGAGCCAATCAATTCTTGCGGAGAACTGTGAATGCGCAAACCAACCCTTGGCCATCGCGTCCGCCATCTCCAGCAGCCGCACGCGGCGCATCTCGGGCAGCGTTGGGTCCT'


# Use search. Remember it only returns the first result!
header = re.search(r'^>.*[0-9]\s', dino)

# Retrieve the matching pattern
header = header.group()

header

'>DinoDNA from Crichton JURASSIC PARK  p. 103 nt 1-1200 '


header_capture = re.search(r'(^>)(.*)([0-9]\s)', dino)

# You can access all capture groups as a tuple (an iterable!)
header_capture. ...


re.findall(..., dna)[0:6] # just the first 6 hits for simplicity


# How many hits are there vs overall length?
(len(re.findall(r'G|C', dna)) /len(dna)) * 100 # CG percent


# Use method-chaining to convert our sequence to mRNA
dna.replace('G', 'X').replace('C', 'G').replace('A', 'U').replace('T', 'A'). ...

# this syntax does sequential replacement, so characters that have already been replaced, are replaced again


# We can make a function that takes three variables
# And returns a single values
test_func = lambda x, y, z: ...

# Give it a try on our named function test_func()
test_func(2, 4, 6)


mrna = re.sub('.', # Find any character 
              # The match object 'm' will be input for our lambda function
              lambda m: {'G':'C', 'C':'G', 'A':'U', 'T':'A'}.get(..., "X"), # Search for the character as a key
              dna # Use 'dna' as the initial search string
             ) # this does what we wanted

# Show us the updated result
mrna


re.search(..., mrna) # reports back only the first hit, says that goes from position 89 to 92 non-inclusive


# corroborate the findings
mrna[...]


# Use the len() function with findall() to count instances of pattern matches
...(re.findall('AUG', mrna))


# Wrap our list comprehension in [] or list()
[(...) for m in re.finditer('AUG', mrna)] # m invokes MatchObject instances (built-in)

# Or cast it as a list. Same result
list((...) for m in re.finditer('AUG', mrna))


# Recall how range() works
# We'll unpack the iterator values with * inside our print() call 

print(...(0, 10, 3))


# We want a range that goes up to the 3rd last base in our mRNA sequence
codon_list = [mrna[...] for i in range(89, len(mrna)-2, 3)]

mrna[89:119] # first 30 bases of mrna

codon_list[0:10] # first 10 codons


# How many times do we see a stop codon in our codon list?

sum(                              # We can sum up a boolean list to get how many True values are present
    (... in ["UAG","UGA","UAA"]     # Use our iterator and check if it is in the list
     for x in codon_list)         # Generate an iterator from each element of the list
)


# Use the join() method to put our codons together
codon_str = ... .join(codon_list)

codon_str[:40]


# Remember what findall() does?
re.findall(r'UAG|UGA|UAA', codon_str)


...(re.findall(r'UAG|UGA|UAA', codon_str))


# More list comprehension using finditer() to grab all the hits and store them in a list
list((m.start(0), m.end(0), ...) for m in re.finditer(r'UAG|UGA|UAA', codon_str))


# split using multiple delimeters (stop codons in this case), and save them as a list

translation = ...('UAG|UGA|UAA', codon_str) # stops at the first encounter of either stop codon

print('Number of strings after splitting: ' + str(len(translation))) # 14 strings after splitting with stop codons

print(type(translation)) # Translation is a list

counter = 1

# Print each string produced by re.split()
for i in translation:
    # Print our split strings and remove the '.' between all codons
    print('split ' + str(counter) + ':' + re.sub('\.', '', i) + '\n')
    counter += 1


# # DNA to Protein
# {'TTT':'F', 'TTC':'F', # Phenylalanine
#  'TTA':'L', 'TTG':'L', 'CTT':'L', 'CTC':'L', 'CTA':'L', 'CTG':'L', # Leucine
#  'ATT':'I', 'ATC':'I', 'ATA':'I', # Isoleucine
#  'ATG', # Methionine
#  'GTT':'V' , 'GTC':'V', 'GTA':'V', 'GTG':'V', # Valine
#  'TCT':'S', 'TCC':'S', 'TCA':'S', 'TCG':'S', # Serine
#  'CCT':'P', 'CCC':'P', 'CCA':'P', 'CCG':'P', # Proline
#  'ACT':'T', 'ACC':'T', 'ACA':'T', 'ACG':'T', # Threonine
#  'GCT':'A', 'GCT':'A', 'GCA':'A', 'GCG':'A', # Alanine
#  'TAT':'Y', 'TAC':'Y', # Tyrosine
#  'TAA':'', 'TAG':'', 'TGA':'',# Stop
#  'CAT':'H', 'CAC':'H', # Histidine
#  'CAA':'Q', 'CAG':'Q', # Glutamine
#  'AAT':'N', 'AAC', # Asparagine
#  'AAT':'N', 'AAC':'N', # Asparagine
#  'AAA':'K', 'AAG':'K', # Lysine
#  'GAT':'D', 'GAC' :'D', # Aspartic acid 
#  'GAA':'E', 'GAG':'E', # Glutamic acid
#  'TGT':'C', 'TGC':'C', # Cysteine
#  'TGG':'W', # Tryptophan
#  'CGT':'R', 'CGC':'R', 'CGA':'R', 'CGG':'R', 'AGA':'R', 'AGG':'R', # Arginine
#  'AGT':'S', 'AGC':'S', # Serine
#  'GGT':'G', 'GGC':'G', 'GGA':'G', 'GGG':'G' # Glycine
# }


# mRNA to Protein
translation_aminoacids = {
    'UUU':'F', 'UUC':'F', # Phenylalanine
    'UUA':'L', 'UUG':'L', 'CUU':'L', 'CUC':'L', 'CUA':'L', 'CUG':'L', # Leucine
    'AUU':'I', 'AUC':'I', 'AUA':'I', # Isoleucine
    'AUG':'M', # Methionine
    'GUU':'V' , 'GUC':'V', 'GUA':'V', 'GUG':'V', # Valine
    'UCU':'S', 'UCC':'S', 'UCA':'S', 'UCG':'S', # Serine
    'CCU':'P', 'CCC':'P', 'CCA':'P', 'CCG':'P', # Proline
    'ACU':'U', 'ACC':'U', 'ACA':'U', 'ACG':'U', # Threonine
    'GCU':'A', 'GCU':'A', 'GCA':'A', 'GCG':'A', # Alanine
    'UAU':'Y', 'UAC':'Y', # Tyrosine
    'UAA':'', 'UAG':'', 'UGA':'',# Stop. We will translate stop codons into nothing for this excercise
    'AUG':'START', # Start
    'CAU':'H', 'CAC':'H', # Histidine
    'CAA':'Q', 'CAG':'Q', # Glutamine
    'AAU':'N', 'AAC':'N', # Asparagine
    'AAA':'K', 'AAG':'K', # Lysine
    'GAU':'D', 'GAC':'D', # Aspartic acid 
    'GAA':'E', 'GAG':'E', # Glutamic acid
    'UGU':'C', 'UGC':'C', # Cysteine
    'UGG':'W', # Tryptophan
    'CGU':'R', 'CGC':'R', 'CGA':'R', 'CGG':'R', 'AGA':'R', 'AGG':'R', # Arginine
    'AGU':'S', 'AGC':'S', # Serine
    'GGU':'G', 'GGC':'G', 'GGA':'G', 'GGG':'G' # Glycine
}


# Clean up our codon sequence and remove the additional "." characters
codon_str_clean = re.sub('\.', '', codon_str)

# Assign a lambda function (to keep the code clean)
translate = lambda loc, seq, codon_dict: codon_dict.get(seq[...], "X")

# Here's how it works
translate(3, codon_str_clean, translation_aminoacids)


# Generate a range that loops through codon positions, translates them, and then joins it all together

# The list comprehension will return a list
''.join([translate(..., codon_str_clean, translation_aminoacids) for x in range(0, len(codon_str_clean)-2, 3)])


# Work with codon_list and iterate through it directly

.join([translation_aminoacids.get(...) for x in ...])


# Import our two packages
import pandas as pd
import numpy as np

# Read in human_microbiome_project_otu_taxa_table_subset.csv
# fill empty cells with NaN -default behavior
data = pd.read_csv('data/human_microbiome_project_otu_taxa_table_subset.csv', na_values=('')) 
data.head()


# Remember how to access a specific row?
data = data.loc[...]
data


# Drop the first column
data.drop('Unnamed: 0', axis = 1, inplace = ...) # remove something with that name from axis 1
data.head()


data_melt = pd.melt(data, 
                    var_name = 'OTU', # Name to use for the 'variable' column (a column containing old column names)
                    value_vars = ...)#, # Column(s) to unpivot (the list of columns that you want to melt)
    
data_melt.head()


# Take the melted data and split on the value column
data_melt_split = data_melt['value'].str.split(..., expand=True) # next, rename columns

# Take a peek at the result
data_melt_split.head()


# We'll change the dataframe in place so that we aren't making extra objects. It will return nothing in this case.
data_melt_split.fillna(value = ..., inplace = True)

data_melt_split.head()


# Concatenate portions of our dataframe by columns
data_melt_split_concat = pd.concat([data_melt['OTU'], data_melt_split.iloc[:, 1:]], ...)

# Check out the result
data_melt_split_concat.head()


# Rename our columns
data_melt_split_concat. ... = ['OTU', 'PHYLUM', 'CLASS', 'ORDER', 'FAMILY', 'GENUS']

# Check the result
data_melt_split_concat.head()


# How will we recognize the correct pattern?
# Use ^ to match to the beginning of the string
# . for any character

re.sub(..., '', 'p__Actinobacteria')


# Use the replace method to drop the prefix in our entries
# ^.\__ = p__Actinobacteria and so on for each tax rank. Replace with nothing
data_melt_split_concat.replace('^.__', '', ..., inplace=True) 

# Take a look at the outcome
data_melt_split_concat.head()


# Use a better regex pattern for your split step!
data_melt['value'].str.split(..., expand=True)


# Import our pandas package
import pandas as pd

# Read in the sequences file as a DataFrame
seq = pd.read_csv(..., sep='\t', header=None)

seq


# Read in the file WITHOUT specifying a separator
seq = pd.read_csv('data/sequences.tsv', header=None)

# Take a look at it
seq.head()

# How big is it?
seq.info()


# Concatenate the ">" to each value
seq = '>' + ...

# Look at the result
seq


import re

# Use the replace method
seq.replace(..., '\n', regex = True, inplace=True)

# Take a look at the result
seq


# Remember to drop the index and headers when writing the data 
seq.to_csv('data/sequences_line_break.fasta', index=..., header=...)


import re

# Read the fasta file back in
seq_back = pd.read_csv('data/sequences_line_break.fasta', header=None)

# Replace \n by \t
seq_back.replace(to_replace = ..., value = ..., regex = True, inplace=True)

# Remove '<' 
seq_back.replace(to_replace = ..., value = ..., regex=True, inplace=True)

# Show us the output before we write to disk
seq_back

# Write sequence_back.csv
seq_back.to_csv('data/seq_back.tsv', index=False, header=False)


# Remember that the "!" accesses the equivalent of our OS command prompt
! file data/sequences.tsv # ASCII is the linux convention


! file data/sequence_Windows.txt # ASCII text, with CRLF line terminators is the Windows convention

Function	Description
findall()	Returns a list containing all matches
finditer()	Returns an iterator containing all matches
search()	Returns a Match object if there is a match anywhere in the string
split()	Returns a list where the string has been split at each match
sub()	Replaces one or many matches with a string
escape()	Escapes any special characters in a pattern that may be unavoidably present

Character	Description	Example
[ ]	A set of characters	"[a-m]"
\	Signals a special sequence (can also be used to escape special characters)	"\d"
.	Any character (except newline character)	"he..o"
^	The search string starts with	"^hello"
\$	The search string ends with	"world\$"
*	Zero or more occurrences	"aix*"
?	Zero or one occurences	"aix?"
+	One or more occurrences	"aix+"
{ }	Exactly the specified number of occurrences	"al{2}"
	Match between 0 and 3 repetitions	"al{,3}
	Match between 3 and 10 repetitions	"al{3,10}
	Match between 3 and infinite repetitions	"al{3,}
\|	Either or	"falls\|stays"
( )	Capture and group	("exact*matches")

Character	Description	Example
\A	Returns a match if the specified characters are at the beginning of the string	"\AThe"
\b	Returns a match where the specified characters are at the beginning or at the end of a word	r"\bain" r"ain\b"
\B	Returns a match where the specified characters are present, but NOT at the beginning (or at the end) of a word	r"\Bain" r"ain\B"
\d	Returns a match where the string contains digits (numbers from 0-9)	"\d"
\D	Returns a match where the string DOES NOT contain digits	"\D"
\s	Returns a match where the string contains a white space character. This includes \s, \t, \n, etc.	"\s"
\S	Returns a match where the string DOES NOT contain a white space character	"\S"
\w	Returns a match where the string contains any word characters (characters from a to Z, digits from 0-9, and the underscore _ character)	"\w"
\W	Returns a match where the string DOES NOT contain any word characters	"\W"
\Z	Returns a match if the specified characters are at the end of the string	"word\Z"

Set	Description
[arn]	Returns a match where one of the specified characters (a, r, or n) are present
[a-n]	Returns a match for any lower case character, alphabetically between a and n
[^arn]	Returns a match for any character EXCEPT a, r, and n. Therefore ^ negates but only within a set
[0123]	Returns a match where any of the specified digits (0, 1, 2, or 3) are present
[0-9]	Returns a match for any digit between 0 and 9
[0-5][0-9]	Returns a match for any two-digit numbers from 00 and 59
[a-zA-Z]	Returns a match for any character alphabetically between a and z, lower case OR upper case
[+]	In sets, +, *, ., \|, (), \$, {} have no special meaning, so [+] means: return a match for any + character in the string

Introduction to Python for Data Science¶

Lecture 06: Strings and Regular Expressions¶

Student Name: Live Lecture HTML¶

Student ID: 220217¶

0.1.0 About Introduction to Python¶

0.1.1 Where is this course headed?¶

0.2.0 Lecture objectives¶

0.3.0 A legend for text format in Jupyter markdown¶

0.4.0 Data used in this lesson¶

0.4.1 Dataset 1: human_microbiome_project_otu_taxa_table_subset.csv¶

0.4.2 Dataset 2: sequences.tsv¶

0.5.0 Packages used in this lesson¶

1.0.0 Regular expressions¶

1.0.1 Regex example with Microsoft word¶

1.1.0 Python’s Regular Expressions (re) library¶

1.1.1. Metacharacters¶

1.1.2 Special Sequences¶

1.1.3 Sets¶

1.1.4 Troubleshooting RegEx¶

1.2.0 Exploring the re RegEx library functions¶

1.2.1 findall() helps to pattern-match within a string¶

1.2.2 search() returns a Match object¶

1.2.3 Break your string up by a pattern using the split() function¶

1.2.4 Replace a pattern in a string using the sub() function¶

1.2.5 Taking a closer look at the re.Match object¶

1.2.6 Escaping the \ escape character with \ and r¶

1.3.0 Take the time to comment your RegEx code¶

2.0.0 The String library¶

2.1.0 Concatenate strings with the +¶

2.2.0 Subset strings by their 0-indexed position¶

2.2.1 String striding slices Strings in a stepped fashion¶

2.3.0 Break a string up using the split() method¶

2.4.0 Concatenate strings in a list using the join() method¶

2.5.0 Use the splitlines() method to remove line boundaries and return a list¶

3.0.0 Regex in action¶

3.1.0 Removing substrings with regex¶

3.1.1 Use lstrip() and rstrip() to remove characters¶

3.1.2 Search for numbers in our header¶

3.1.3 Capture whitespace using the \s pattern¶

3.1.4 Another way to capture those white spaces is with sub()¶

3.1.5 Combine multiple patterns to make a single regular expression¶

3.1.6 Repetition qualifiers are greedy!¶

3.2.0 Extract information from strings with search()¶

3.2.1 Capture groups save information about your matches¶

3.3.0 Searching strings for information¶

3.4.0 Replacing parts of your string¶

3.4.1 Generate a lambda function to help replace multiple patterns/values¶

3.4.2 Use sub() in conjunction with a lambda function¶

3.5.0 Searching our mRNA sequence for information¶

3.5.1 Remember to use findall() to look for multiple hits¶

3.5.2 Retrieve an iterator of multiple hits wth finditer()¶

3.5.3 Split our mRNA sequence into codons with a skipped range() call¶

3.5.4 Convert our codon list to a single string¶

3.5.5 Split codon_str by stop codon sequence with split()¶

3.5.6 Translate codons into amino acid sequences¶

4.0.0 Regular expressions and Pandas¶

4.1.0 Retain only the first row by indexing¶

4.1.1 Drop columns with the drop() method¶

4.2.0 Melt the data frame into long format with melt()¶

4.3.0 Split entries by their ; delimiters with pandas.Series.str.split()¶

4.3.1 Replace the None values using the fill.na() method¶

4.4.0 Bring back the OTU column with the concat() function¶

4.4.1 Rename the columns using proper taxonomic ranks¶

4.5.0 Remove the additional x__ prefixes from our values¶

4.5.1 Change values in a DataFrame using the replace() method¶

4.5.2 Take advantage of patterns to optimize your Regex!¶

4.6.0 Another data-formatting challenge¶

4.6.1 Append the > character to each sequence line¶

4.6.2 Complete the fasta sequence format by replacing the \t¶

4.6.3 Write your DataFrame to disk with to_csv()¶

5.0.0 Class summary¶

5.1.0 Submit your completed skeleton notebook (2% of final grade)¶

5.2.0 Post-lecture DataCamp assessment (8% of final grade)¶

5.3.0 Acknowledgements¶

5.4.0 Resources¶

6.0.0 Appendix 1¶

6.1.0 End-of-Line Characters: Unix vs. Windows**¶

The Center for the Analysis of Genome Evolution and Function (CAGEF)¶

1.1.0 Python’s Regular Expressions (`re`) library¶

1.2.0 Exploring the `re` RegEx library functions¶

1.2.1 `findall()` helps to pattern-match within a string¶

1.2.2 `search()` returns a `Match` object¶

1.2.3 Break your string up by a pattern using the `split()` function¶

1.2.4 Replace a pattern in a string using the `sub()` function¶

1.2.5 Taking a closer look at the `re.Match` object¶

1.2.6 Escaping the `\` escape character with `\` and `r`¶

2.1.0 Concatenate strings with the `+`¶

2.3.0 Break a string up using the `split()` method¶

2.4.0 Concatenate strings in a list using the `join()` method¶

2.5.0 Use the `splitlines()` method to remove line boundaries and return a list¶

3.1.1 Use `lstrip()` and `rstrip()` to remove characters¶

3.1.3 Capture whitespace using the `\s` pattern¶

3.1.4 Another way to capture those white spaces is with `sub()`¶

3.2.0 Extract information from strings with `search()`¶

3.4.1 Generate a `lambda` function to help replace multiple patterns/values¶

3.4.2 Use `sub()` in conjunction with a `lambda` function¶

3.5.1 Remember to use `findall()` to look for multiple hits¶

3.5.2 Retrieve an iterator of multiple hits wth `finditer()`¶

3.5.3 Split our mRNA sequence into codons with a skipped `range()` call¶

3.5.5 Split `codon_str` by stop codon sequence with `split()`¶

4.1.1 Drop columns with the `drop()` method¶

4.2.0 Melt the data frame into long format with `melt()`¶

4.3.0 Split entries by their `;` delimiters with `pandas.Series.str.split()`¶

4.3.1 Replace the `None` values using the `fill.na()` method¶

4.4.0 Bring back the OTU column with the `concat()` function¶

4.5.0 Remove the additional `x__` prefixes from our values¶

4.5.1 Change values in a DataFrame using the `replace()` method¶

4.6.1 Append the `>` character to each sequence line¶

4.6.2 Complete the fasta sequence format by replacing the `\t`¶

4.6.3 Write your DataFrame to disk with `to_csv()`¶